package com.quan.demo.util;

import java.beans.PropertyEditorSupport;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.Month;
import java.util.*;

import org.springframework.util.StringUtils;

/**
 * 类描述：时间操作定义类
 *
 * @Author: 张代浩
 * @Date:2012-12-8 12:15:03
 * @Version 1.0
 */
public class DateUtils extends PropertyEditorSupport {
    // 各种时间格式
    public static final SimpleDateFormat date_sdf = new SimpleDateFormat("yyyy-MM-dd");
    // 各种时间格式
    public static final SimpleDateFormat yyyyMMdd = new SimpleDateFormat("yyyyMMdd");
    // 各种时间格式
    public static final SimpleDateFormat date_sdf_wz = new SimpleDateFormat("yyyy年MM月dd日");
    public static final SimpleDateFormat time_sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
    public static final SimpleDateFormat yyyymmddhhmmss = new SimpleDateFormat("yyyyMMddHHmmss");
    public static final SimpleDateFormat short_time_sdf = new SimpleDateFormat("HH:mm");
    public static final SimpleDateFormat datetimeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //ISO8601格式时间 例如2019-12-17T10:34:00+0800
    public static final SimpleDateFormat yyyy_MM_dd_HH_mm_ss_ZZ = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZZ");
    //ISO8601格式时间 例如2019-12-17T10:34:00+08:00
    public static final SimpleDateFormat yyyy_MM_dd_HH_mm_ss_XXX = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX");
    // 以毫秒表示的时间
    private static final long DAY_IN_MILLIS = 24 * 3600 * 1000;
    private static final long HOUR_IN_MILLIS = 3600 * 1000;
    private static final long MINUTE_IN_MILLIS = 60 * 1000;
    private static final long SECOND_IN_MILLIS = 1000;

    // 指定模式的时间格式
    private static SimpleDateFormat getSDFormat(String pattern) {
        return new SimpleDateFormat(pattern);
    }

    /**
     * 当前日历，这里用中国时间表示
     *
     * @return 以当地时区表示的系统当前日历
     */
    public static Calendar getCalendar() {
        return Calendar.getInstance();
    }

    /**
     * 指定毫秒数表示的日历
     *
     * @param millis 毫秒数
     * @return 指定毫秒数表示的日历
     */
    public static Calendar getCalendar(long millis) {
        Calendar cal = Calendar.getInstance();
        // --------------------cal.setTimeInMillis(millis);
        cal.setTime(new Date(millis));
        return cal;
    }

    // ////////////////////////////////////////////////////////////////////////////
    // getDate
    // 各种方式获取的Date
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 当前日期
     *
     * @return 系统当前时间
     */
    public static Date getDate() {
        return new Date();
    }

    /**
     * 指定毫秒数表示的日期
     *
     * @param millis 毫秒数
     * @return 指定毫秒数表示的日期
     */
    public static Date getDate(long millis) {
        return new Date(millis);
    }

    /**
     * 时间戳转换为字符串
     *
     * @param time
     * @return
     */
    public static String timestamptoStr(Timestamp time) {
        Date date = null;
        if (null != time) {
            date = new Date(time.getTime());
        }
        return date2Str(date_sdf);
    }

    /**
     * 字符串转换时间戳
     *
     * @param str
     * @return
     */
    public static Timestamp str2Timestamp(String str) {
        Date date = str2Date(str, date_sdf);
        return new Timestamp(date.getTime());
    }

    /**
     * 字符串转换Date
     *
     * @param str
     * @return
     */
    public static Date str2Date(String str) {
        Date date = str2Date(str, datetimeFormat);
        return date;
    }

    /**
     * 字符串转换Date
     *
     * @param str
     * @return
     */
    public static Date str2Date2(String str) {
        Date date = str2Date(str, date_sdf);
        return date;
    }


    /**
     * 字符串转换成日期
     *
     * @param str
     * @param sdf
     * @return
     */
    public static Date str2Date(String str, SimpleDateFormat sdf) {
        if (null == str || "".equals(str)) {
            return null;
        }
        Date date = null;
        try {
            date = sdf.parse(str);
            return date;
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 日期转换为字符串
     *
     * @param date_sdf 日期格式
     * @return 字符串
     */
    public static String date2Str(SimpleDateFormat date_sdf) {
        Date date = getDate();
        if (null == date) {
            return null;
        }
        return date_sdf.format(date);
    }

    /**
     * 格式化时间
     *
     * @param date
     * @param format
     * @return
     */
    public static String dateformat(String date, String format) {
        SimpleDateFormat sformat = new SimpleDateFormat(format);
        Date _date = null;
        try {
            _date = sformat.parse(date);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return sformat.format(_date);
    }

    /**
     * 日期转换为字符串
     *
     * @param date     日期
     * @param date_sdf 日期格式
     * @return 字符串
     */
    public static String date2Str(Date date, SimpleDateFormat date_sdf) {
        if (null == date) {
            return null;
        }
        return date_sdf.format(date);
    }

    /**
     * 日期转换为字符串
     *
     * @param format 日期格式
     * @return 字符串
     */
    public static String getDate(String format) {
        Date date = new Date();
        if (null == date) {
            return null;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(date);
    }

    /**
     * 指定毫秒数的时间戳
     *
     * @param millis 毫秒数
     * @return 指定毫秒数的时间戳
     */
    public static Timestamp getTimestamp(long millis) {
        return new Timestamp(millis);
    }

    /**
     * 以字符形式表示的时间戳
     *
     * @param time 毫秒数
     * @return 以字符形式表示的时间戳
     */
    public static Timestamp getTimestamp(String time) {
        return new Timestamp(Long.parseLong(time));
    }

    /**
     * 系统当前的时间戳
     *
     * @return 系统当前的时间戳
     */
    public static Timestamp getTimestamp() {
        return new Timestamp(System.currentTimeMillis());
    }

    /**
     * 当前时间，格式 yyyy-MM-dd HH:mm:ss
     *
     * @return 当前时间的标准形式字符串
     */
    public static String now() {
        return datetimeFormat.format(getCalendar().getTime());
    }

    /**
     * 指定日期的时间戳
     *
     * @param date 指定日期
     * @return 指定日期的时间戳
     */
    public static Timestamp getTimestamp(Date date) {
        return new Timestamp(date.getTime());
    }

    /**
     * 指定日历的时间戳
     *
     * @param cal 指定日历
     * @return 指定日历的时间戳
     */
    public static Timestamp getCalendarTimestamp(Calendar cal) {
        // ---------------------return new Timestamp(cal.getTimeInMillis());
        return new Timestamp(cal.getTime().getTime());
    }

    public static Timestamp gettimestamp() {
        Date dt = new Date();
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String nowTime = df.format(dt);
        Timestamp buydate = Timestamp.valueOf(nowTime);
        return buydate;
    }

    // ////////////////////////////////////////////////////////////////////////////
    // getMillis
    // 各种方式获取的Millis
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 系统时间的毫秒数
     *
     * @return 系统时间的毫秒数
     */
    public static long getMillis() {
        return System.currentTimeMillis();
    }

    /**
     * 指定日历的毫秒数
     *
     * @param cal 指定日历
     * @return 指定日历的毫秒数
     */
    public static long getMillis(Calendar cal) {
        // --------------------return cal.getTimeInMillis();
        return cal.getTime().getTime();
    }

    /**
     * 指定日期的毫秒数
     *
     * @param date 指定日期
     * @return 指定日期的毫秒数
     */
    public static long getMillis(Date date) {
        return date.getTime();
    }

    /**
     * 指定时间戳的毫秒数
     *
     * @param ts 指定时间戳
     * @return 指定时间戳的毫秒数
     */
    public static long getMillis(Timestamp ts) {
        return ts.getTime();
    }

    // ////////////////////////////////////////////////////////////////////////////
    // formatDate
    // 将日期按照一定的格式转化为字符串
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 默认方式表示的系统当前日期，具体格式：年-月-日
     *
     * @return 默认日期按“年-月-日“格式显示
     */
    public static String formatDate() {
        return date_sdf.format(getCalendar().getTime());
    }

    /**
     * 默认方式表示的系统当前日期，具体格式：yyyy-MM-dd HH:mm:ss
     *
     * @return 默认日期按“yyyy-MM-dd HH:mm:ss“格式显示
     */
    public static String formatDateTime() {
        return datetimeFormat.format(getCalendar().getTime());
    }

    /**
     * 获取时间字符串
     */
    public static String getDataString(SimpleDateFormat formatstr) {
        return formatstr.format(getCalendar().getTime());
    }

    /**
     * 指定日期的默认显示，具体格式：年-月-日
     *
     * @param cal 指定的日期
     * @return 指定日期按“年-月-日“格式显示
     */
    public static String formatDate(Calendar cal) {
        return date_sdf.format(cal.getTime());
    }

    /**
     * 指定日期的默认显示，具体格式：年-月-日
     *
     * @param date 指定的日期
     * @return 指定日期按“年-月-日“格式显示
     */
    public static String formatDate(Date date) {
        return date_sdf.format(date);
    }

    /**
     * 指定毫秒数表示日期的默认显示，具体格式：年-月-日
     *
     * @param millis 指定的毫秒数
     * @return 指定毫秒数表示日期按“年-月-日“格式显示
     */
    public static String formatDate(long millis) {
        return date_sdf.format(new Date(millis));
    }

    /**
     * 默认日期按指定格式显示
     *
     * @param pattern 指定的格式
     * @return 默认日期按指定格式显示
     */
    public static String formatDate(String pattern) {
        return getSDFormat(pattern).format(getCalendar().getTime());
    }

    /**
     * 指定日期按指定格式显示
     *
     * @param cal     指定的日期
     * @param pattern 指定的格式
     * @return 指定日期按指定格式显示
     */
    public static String formatDate(Calendar cal, String pattern) {
        return getSDFormat(pattern).format(cal.getTime());
    }

    /**
     * 指定日期按指定格式显示
     *
     * @param date    指定的日期
     * @param pattern 指定的格式
     * @return 指定日期按指定格式显示
     */
    public static String formatDate(Date date, String pattern) {
        return getSDFormat(pattern).format(date);
    }

    // ////////////////////////////////////////////////////////////////////////////
    // formatTime
    // 将日期按照一定的格式转化为字符串
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 默认方式表示的系统当前日期，具体格式：年-月-日 时：分
     *
     * @return 默认日期按“年-月-日 时：分“格式显示
     */
    public static String formatTime() {
        return time_sdf.format(getCalendar().getTime());
    }

    /**
     * 指定毫秒数表示日期的默认显示，具体格式：年-月-日 时：分
     *
     * @param millis 指定的毫秒数
     * @return 指定毫秒数表示日期按“年-月-日 时：分“格式显示
     */
    public static String formatTime(long millis) {
        return time_sdf.format(new Date(millis));
    }

    /**
     * 指定日期的默认显示，具体格式：年-月-日 时：分
     *
     * @param cal 指定的日期
     * @return 指定日期按“年-月-日 时：分“格式显示
     */
    public static String formatTime(Calendar cal) {
        return time_sdf.format(cal.getTime());
    }

    /**
     * 指定日期的默认显示，具体格式：年-月-日 时：分
     *
     * @param date 指定的日期
     * @return 指定日期按“年-月-日 时：分“格式显示
     */
    public static String formatTime(Date date) {
        return time_sdf.format(date);
    }

    // ////////////////////////////////////////////////////////////////////////////
    // formatShortTime
    // 将日期按照一定的格式转化为字符串
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 默认方式表示的系统当前日期，具体格式：时：分
     *
     * @return 默认日期按“时：分“格式显示
     */
    public static String formatShortTime() {
        return short_time_sdf.format(getCalendar().getTime());
    }

    /**
     * 指定毫秒数表示日期的默认显示，具体格式：时：分
     *
     * @param millis 指定的毫秒数
     * @return 指定毫秒数表示日期按“时：分“格式显示
     */
    public static String formatShortTime(long millis) {
        return short_time_sdf.format(new Date(millis));
    }

    /**
     * 指定日期的默认显示，具体格式：时：分
     *
     * @param cal 指定的日期
     * @return 指定日期按“时：分“格式显示
     */
    public static String formatShortTime(Calendar cal) {
        return short_time_sdf.format(cal.getTime());
    }

    /**
     * 指定日期的默认显示，具体格式：时：分
     *
     * @param date 指定的日期
     * @return 指定日期按“时：分“格式显示
     */
    public static String formatShortTime(Date date) {
        return short_time_sdf.format(date);
    }

    // ////////////////////////////////////////////////////////////////////////////
    // parseDate
    // parseCalendar
    // parseTimestamp
    // 将字符串按照一定的格式转化为日期或时间
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
     *
     * @param src     将要转换的原始字符窜
     * @param pattern 转换的匹配格式
     * @return 如果转换成功则返回转换后的日期
     * @throws ParseException
     */
    public static Date parseDate(String src, String pattern) throws ParseException {
        return getSDFormat(pattern).parse(src);

    }

    /**
     * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
     *
     * @param date    将要转换的日期
     * @param pattern 转换的匹配格式
     * @return 如果转换成功则返回转换后的日期
     * @throws ParseException
     */
    public static Date parseDate(Date date, String pattern) {
        String src = date2Str(date, new SimpleDateFormat(pattern));
        try {
            return getSDFormat(pattern).parse(src);
        } catch (ParseException e) {
//			e.printStackTrace();
            System.out.println(e.getMessage());
            return null;
        }
    }

    /**
     * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
     *
     * @param src     将要转换的原始字符窜
     * @param pattern 转换的匹配格式
     * @return 如果转换成功则返回转换后的日期
     * @throws ParseException
     */
    public static Calendar parseCalendar(String src, String pattern) throws ParseException {

        Date date = parseDate(src, pattern);
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal;
    }

    public static String formatAddDate(String src, String pattern, int amount) throws ParseException {
        Calendar cal;
        cal = parseCalendar(src, pattern);
        cal.add(Calendar.DATE, amount);
        return formatDate(cal);
    }

    public static String formatAddDate(String src, String pattern, int amount, int amountUnit) throws ParseException {
        Calendar cal;
        cal = parseCalendar(src, pattern);
        cal.add(amountUnit, amount);
        return formatDate(cal, "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
     *
     * @param src     将要转换的原始字符窜
     * @param pattern 转换的匹配格式
     * @return 如果转换成功则返回转换后的时间戳
     * @throws ParseException
     */
    public static Timestamp parseTimestamp(String src, String pattern) throws ParseException {
        Date date = parseDate(src, pattern);
        return new Timestamp(date.getTime());
    }

    // ////////////////////////////////////////////////////////////////////////////
    // dateDiff
    // 计算两个日期之间的差值
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 计算两个时间之间的差值，根据标志的不同而不同
     *
     * @param flag   计算标志，表示按照年/月/日/时/分/秒等计算
     * @param calSrc 减数
     * @param calDes 被减数
     * @return 两个日期之间的差值
     */
    public static int dateDiff(char flag, Calendar calSrc, Calendar calDes) {

        long millisDiff = getMillis(calSrc) - getMillis(calDes);

        if (flag == 'y') {
            return (calSrc.get(calSrc.YEAR) - calDes.get(calDes.YEAR));
        }

        if (flag == 'd') {
            return (int) (millisDiff / DAY_IN_MILLIS);
        }

        if (flag == 'h') {
            return (int) (millisDiff / HOUR_IN_MILLIS);
        }

        if (flag == 'm') {
            return (int) (millisDiff / MINUTE_IN_MILLIS);
        }

        if (flag == 's') {
            return (int) (millisDiff / SECOND_IN_MILLIS);
        }

        return 0;
    }
    // ////////////////////////////////////////////////////////////////////////////
    // dateDiff
    // 计算两个日期之间的差值
    // ////////////////////////////////////////////////////////////////////////////

    /**
     * 计算两个时间之间的差值，根据标志的不同而不同
     *
     * @param flag   计算标志，表示按照年/月/日/时/分/秒等计算
     * @param calSrc 减数
     * @param calDes 被减数
     * @return 两个日期之间的差值
     */
    public static Double dateDiffDouble(char flag, Calendar calSrc, Calendar calDes) {

        long millisDiff = getMillis(calSrc) - getMillis(calDes);

        if (flag == 'y') {
            return BigDecimal.valueOf(calSrc.get(calSrc.YEAR) - calDes.get(calDes.YEAR)).setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue();
        }

        if (flag == 'd') {
//			System.out.println(millisDiff);
//			System.out.println(DAY_IN_MILLIS);
//			System.out.println(BigDecimal.valueOf(millisDiff).divide(BigDecimal.valueOf(DAY_IN_MILLIS),1, RoundingMode.HALF_UP));
//			System.out.println(BigDecimal.valueOf(millisDiff).divide(BigDecimal.valueOf(DAY_IN_MILLIS),1, RoundingMode.HALF_DOWN));
//			System.out.println(BigDecimal.valueOf(millisDiff).divide(BigDecimal.valueOf(DAY_IN_MILLIS),1, RoundingMode.HALF_EVEN));
//			System.out.println(BigDecimal.valueOf(millisDiff).divide(BigDecimal.valueOf(DAY_IN_MILLIS),1, RoundingMode.FLOOR));
//			System.out.println(BigDecimal.valueOf(millisDiff).divide(BigDecimal.valueOf(DAY_IN_MILLIS),1, RoundingMode.DOWN));
//			return BigDecimal.valueOf(millisDiff / DAY_IN_MILLIS).setScale(2,BigDecimal.ROUND_DOWN).doubleValue();
            return BigDecimal.valueOf(millisDiff).divide(BigDecimal.valueOf(DAY_IN_MILLIS), 1, RoundingMode.HALF_UP).doubleValue();
        }

        if (flag == 'h') {
            return BigDecimal.valueOf(millisDiff / HOUR_IN_MILLIS).setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue();
        }

        if (flag == 'm') {
            return BigDecimal.valueOf(millisDiff / MINUTE_IN_MILLIS).setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue();
        }

        if (flag == 's') {
            return BigDecimal.valueOf(millisDiff / SECOND_IN_MILLIS).setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue();
        }

        return 0.00;
    }

    /**
     * String类型 转换为Date, 如果参数长度为10 转换格式”yyyy-MM-dd“ 如果参数长度为19 转换格式”yyyy-MM-dd
     * HH:mm:ss“ * @param text String类型的时间值
     */
    @Override
    public void setAsText(String text) throws IllegalArgumentException {
        if (StringUtils.hasText(text)) {
            try {
                if (text.indexOf(":") == -1 && text.length() == 10) {
                    setValue(this.date_sdf.parse(text));
                } else if (text.indexOf(":") > 0 && text.length() == 19) {
                    setValue(this.datetimeFormat.parse(text));
                } else {
                    throw new IllegalArgumentException("Could not parse date, date format is error ");
                }
            } catch (ParseException ex) {
                IllegalArgumentException iae = new IllegalArgumentException("Could not parse date: " + ex.getMessage());
                iae.initCause(ex);
                throw iae;
            }
        } else {
            setValue(null);
        }
    }

    public static int getYear() {
        GregorianCalendar calendar = new GregorianCalendar();
        calendar.setTime(getDate());
        return calendar.get(Calendar.YEAR);
    }

    public static void main(String[] args) {
        System.out.println(formatTime(hourAddNum(new Date(), 8)));
//		String date = "1982-02-02 13:12:23";
        String date = "1982-02-02";
        try {
//			System.out.println(getAgeByBirthDay(str2Date(date,yyyyMMdd)));
            System.out.println(yearAddNum(new Date(), 9));
            System.out.println(getAgeByBirthDay(yearAddNum(new Date(), -9)));
            System.out.println(getMonthEndDate(parseDate("2020-04", "yyyy-MM")));
            System.out.println(getMonthStartDate(parseDate("2020-04", "yyyy-MM")));

            System.out.println("===========");
            System.out.println(DateUtils.date2Str(getBirthDayByAge(3), date_sdf));
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(new Date());
        GregorianCalendar ca = new GregorianCalendar();
        if (ca.get(GregorianCalendar.AM_PM) == 0) {
            System.out.print("上午好");
        } else {
            System.out.println("下午好");
        }
        System.out.println("星期==" + getWeek("2020-07-31"));
        System.out.println("星期2==" + getWeek(new Date()));
        System.out.println("=========================");
        System.out.println(date2Str(yyyy_MM_dd_HH_mm_ss_XXX));
        Calendar calendar_end = Calendar.getInstance();
        calendar_end.setTime(DateUtils.str2Date("2021-01-22 01:00:00", DateUtils.datetimeFormat));
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        System.out.println("===" + dateDiffDouble('d', calendar, calendar_end));
        System.out.println("===" + dateDiff('d', calendar, calendar_end));

        Calendar c11 = Calendar.getInstance();
        c11.setTime(DateUtils.str2Date("2020-07-30 08:00:00", DateUtils.datetimeFormat));
        System.out.println(c11.get(Calendar.HOUR_OF_DAY));
        Calendar c12 = Calendar.getInstance();
        c12.setTime(new Date());
        c12.set(Calendar.HOUR_OF_DAY, c11.get(Calendar.HOUR_OF_DAY));
        c12.set(Calendar.MINUTE, c11.get(Calendar.MINUTE));
        c12.set(Calendar.SECOND, c11.get(Calendar.SECOND));
        System.out.println(c12.getTime());

        System.out.println("==============================================");
        System.out.println("=====================今天开始时间=========================" + getStartTime(new Date()));
        System.out.println("=====================今天结束时间=========================" + getEndTime(new Date()));
        System.out.println("=====================今天的前7天开始时间=========================" + getStartTime(dayAddNum(new Date(), -7)));
        System.out.println("=====================今天的后7天结束时间=========================" + getEndTime(dayAddNum(new Date(), 7)));
        System.out.println("=====================昨天开始时间=========================" + getYesterdayStartTime());
        System.out.println("=====================昨天结束时间=========================" + getYesterdayEndTime());
        System.out.println("=====================本周开始时间=========================" + getBeginWeekDate());
        System.out.println("=====================本周结束时间=========================" + getEndWeekDate());
        System.out.println("=====================new Date()所在周开始时间=========================" + getBeginWeekDate(new Date()));
        System.out.println("=====================new Date()所在周结束时间=========================" + getEndWeekDate(new Date()));
        System.out.println("=====================new Date()+7所在周开始时间=========================" + getBeginWeekDate(dayAddNum(new Date(), 7)));
        System.out.println("=====================new Date()+7所在周结束时间=========================" + getEndWeekDate(dayAddNum(new Date(), 7)));
        System.out.println("=====================本月开始时间=========================" + getMonthStartDate());
        System.out.println("=====================本月结束时间=========================" + getMonthEndDate());
        System.out.println("=====================本季度开始时间=========================" + getStartOrEndDayOfQuarter(LocalDate.now(), true));
        System.out.println("=====================本季度结束时间=========================" + getStartOrEndDayOfQuarter(LocalDate.now(), false));
        System.out.println("=====================本年开始时间=========================" + getStartOrEndDayOfYear(LocalDate.now(), true));
        System.out.println("=====================本年结束时间=========================" + getStartOrEndDayOfYear(LocalDate.now(), false));
        System.out.println("=================某一天是周几================" + getWeekdayOfDateTime(new Date()));
//		randomDate();
        System.out.println(addTime());
//		addTime();
    }

    /**
     * 将originDate中的年月日替换为targetDate中的年月日
     *
     * @param originDate
     * @param targetDate
     * @return
     */
    public static Date replace_yyyyMMdd(Date originDate, Date targetDate) {
        if (originDate == null || targetDate == null) {
            return null;
        }
        Calendar c_o = Calendar.getInstance();
        c_o.setTime(originDate);
        Calendar c_t = Calendar.getInstance();
        c_t.setTime(targetDate);
        c_t.set(Calendar.HOUR_OF_DAY, c_o.get(Calendar.HOUR_OF_DAY));
        c_t.set(Calendar.MINUTE, c_o.get(Calendar.MINUTE));
        c_t.set(Calendar.SECOND, c_o.get(Calendar.SECOND));
        return c_t.getTime();
    }

    /**
     * 判断指定时间是否是上午
     *
     * @param date
     * @return true  上午  false  下午
     */
    public static Boolean isAm(Date date) {
        GregorianCalendar ca = new GregorianCalendar();
        if (date != null) {
            ca.setTime(date);
        }
        return ca.get(GregorianCalendar.AM_PM) == 0;
    }

    /**
     * 日期相加减
     *
     * @param time 时间字符串 yyyy-MM-dd HH:mm:ss
     * @param num  加的数，-num就是减去
     * @return 减去相应的数量的年的日期
     * @throws ParseException
     */
    public static Date yearAddNum(Date time, Integer num) {
        //SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //Date date = format.parse(time);

        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);
        calendar.add(Calendar.YEAR, num);
        Date newTime = calendar.getTime();
        return newTime;
    }

    /**
     * @param time 时间
     * @param num  加的数，-num就是减去
     * @return 减去相应的数量的月份的日期
     * @throws ParseException Date
     */
    public static Date monthAddNum(Date time, Integer num) {
        //SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //Date date = format.parse(time);

        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);
        calendar.add(Calendar.MONTH, num);
        Date newTime = calendar.getTime();
        return newTime;
    }

    /**
     * @param time 时间
     * @param num  加的数，-num就是减去
     * @return 减去相应的数量的天的日期
     * @throws ParseException Date
     */
    public static Date dayAddNum(Date time, Integer num) {
        //SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //Date date = format.parse(time);

        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);
        calendar.add(Calendar.DAY_OF_MONTH, num);
        Date newTime = calendar.getTime();
        return newTime;
    }

    /**
     * @param time 时间
     * @param num  加的数，-num就是减去
     * @return 减去相应的数量的天的日期
     * @throws ParseException Date
     */
    public static Date hourAddNum(Date time, Integer num) {
        //SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //Date date = format.parse(time);

        Calendar calendar = Calendar.getInstance();
        calendar.setTime(time);
        calendar.add(Calendar.HOUR_OF_DAY, num);
        Date newTime = calendar.getTime();
        return newTime;
    }


    /**
     * 获取本月第一天时间
     */
    public static Date getMonthStartDate() {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    /**
     * 获取本月最后一天
     */
    public static Date getMonthEndDate() {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 999);
        return calendar.getTime();
    }

    /**
     * 获取指定月份第一天时间00:00:00
     */
    public static Date getMonthStartDate(Date month) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(month);
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        return calendar.getTime();
    }

    /**
     * 获取指定月份最后一天23:59:59
     */
    public static Date getMonthEndDate(Date month) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(month);
        calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
        calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH), 23, 59, 59);
        return calendar.getTime();
    }

    /**
     * 获取本周的开始时间
     */
    public static Date getBeginWeekDate() {
        Calendar cal = Calendar.getInstance();
        cal.setTime(new Date());
        int dayofweek = cal.get(Calendar.DAY_OF_WEEK);
        //周日是1 ，周一是 2 ，周二是 3
        //所以，当周的第一天 = 当前日期 - 距离周一过了几天（周一过了0天，周二过了1天，   周日过了6天）
        // 2 - 周一的（dayofweek：2 ）= 0
        // 2 - 周二的（dayofweek：3 ）= -1
        //                      .
        //                      .
        // 2 - 周日的（dayofweek：1） = 1（这个是不符合的需要我们修改）===》2 - 周日的（dayofweek：1 ==》8 ） = -6
        if (dayofweek == 1) {
            dayofweek += 7;
        }
        cal.add(Calendar.DATE, 2 - dayofweek);
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        return cal.getTime();
    }


    /**
     * 本周的结束时间
     * 开始时间 + 6天
     */
    public static Date getEndWeekDate() {
        Calendar cal = Calendar.getInstance();
        cal.setTime(new Date());
        int dayofweek = cal.get(Calendar.DAY_OF_WEEK);
        if (dayofweek == 1) {
            dayofweek += 7;
        }
        cal.add(Calendar.DATE, 8 - dayofweek);//2 - dayofweek + 6
        cal.set(Calendar.HOUR_OF_DAY, 23);
        cal.set(Calendar.MINUTE, 59);
        cal.set(Calendar.SECOND, 59);
        cal.set(Calendar.MILLISECOND, 999);
        return cal.getTime();
    }

    /**
     * 获取指定日期所在周的开始时间
     */
    public static Date getBeginWeekDate(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        int dayofweek = cal.get(Calendar.DAY_OF_WEEK);
        //周日是1 ，周一是 2 ，周二是 3
        //所以，当周的第一天 = 当前日期 - 距离周一过了几天（周一过了0天，周二过了1天，   周日过了6天）
        // 2 - 周一的（dayofweek：2 ）= 0
        // 2 - 周二的（dayofweek：3 ）= -1
        //                      .
        //                      .
        // 2 - 周日的（dayofweek：1） = 1（这个是不符合的需要我们修改）===》2 - 周日的（dayofweek：1 ==》8 ） = -6
        if (dayofweek == 1) {
            dayofweek += 7;
        }
        cal.add(Calendar.DATE, 2 - dayofweek);
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        return cal.getTime();
    }


    /**
     * 获取指定日期所在周的结束时间
     * 开始时间 + 6天
     */
    public static Date getEndWeekDate(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        int dayofweek = cal.get(Calendar.DAY_OF_WEEK);
        if (dayofweek == 1) {
            dayofweek += 7;
        }
        cal.add(Calendar.DATE, 8 - dayofweek);//2 - dayofweek + 6
        cal.set(Calendar.HOUR_OF_DAY, 23);
        cal.set(Calendar.MINUTE, 59);
        cal.set(Calendar.SECOND, 59);
        cal.set(Calendar.MILLISECOND, 999);
        return cal.getTime();
    }

    public static int getAgeByBirthDay(Date birthDay) {
        Calendar cal = Calendar.getInstance();
        if (cal.before(birthDay)) { //出生日期晚于当前时间，无法计算
//			throw new IllegalArgumentException(
//					"The birthDay is before Now.It's unbelievable!");
            return 0;
        }
        int yearNow = cal.get(Calendar.YEAR);  //当前年份
        int monthNow = cal.get(Calendar.MONTH);  //当前月份
        int dayOfMonthNow = cal.get(Calendar.DAY_OF_MONTH); //当前日期
        cal.setTime(birthDay);
        int yearBirth = cal.get(Calendar.YEAR);
        int monthBirth = cal.get(Calendar.MONTH);
        int dayOfMonthBirth = cal.get(Calendar.DAY_OF_MONTH);
        int age = yearNow - yearBirth;   //计算整岁数
        if (monthNow <= monthBirth) {
            if (monthNow == monthBirth) {
                if (dayOfMonthNow < dayOfMonthBirth) age--;//当前日期在生日之前，年龄减一
            } else {
                age--;//当前月份在生日之前，年龄减一
            }
        }
        return age;
    }

    public static Date getBirthDayByAge(Integer age) {
        Calendar cal = Calendar.getInstance();
        if (age < 0) {
            age = 0;
        }
        cal.setTime(new Date());
        cal.add(Calendar.YEAR, -age);
        Date date = cal.getTime();
        return date;
    }

    /**
     * 获取今天开始时间
     */
    public static Long getStartTime() {
        Calendar todayStart = Calendar.getInstance();
        todayStart.set(Calendar.HOUR, 0);
        todayStart.set(Calendar.MINUTE, 0);
        todayStart.set(Calendar.SECOND, 0);
        todayStart.set(Calendar.MILLISECOND, 0);
        return todayStart.getTime().getTime();
    }

    /**
     * 获取今天结束时间
     */
    public static Long getEndTime() {
        Calendar todayEnd = Calendar.getInstance();
        todayEnd.set(Calendar.HOUR, 23);
        todayEnd.set(Calendar.MINUTE, 59);
        todayEnd.set(Calendar.SECOND, 59);
        todayEnd.set(Calendar.MILLISECOND, 999);
        return todayEnd.getTime().getTime();
    }

    /**
     * 获取每天的开始时间 00:00:00:00
     *
     * @param date
     * @return
     */
    public static Date getStartTime(Date date) {
        Calendar dateStart = Calendar.getInstance();
        dateStart.setTime(date);
        dateStart.set(Calendar.HOUR_OF_DAY, 0);
        dateStart.set(Calendar.MINUTE, 0);
        dateStart.set(Calendar.SECOND, 0);
        dateStart.set(Calendar.MILLISECOND, 0);
        return dateStart.getTime();
    }

    /**
     * 获取昨天的结束时间 23:59:59:999
     *
     * @return
     */
    public static Date getYesterdayEndTime() {
        Date date = new Date();
        Calendar dateEnd = Calendar.getInstance();
        dateEnd.setTime(date);
        dateEnd.add(Calendar.DATE, -1);
        dateEnd.set(Calendar.HOUR_OF_DAY, 23);
        dateEnd.set(Calendar.MINUTE, 59);
        dateEnd.set(Calendar.SECOND, 59);
        dateEnd.set(Calendar.MILLISECOND, 999);
        return dateEnd.getTime();
    }

    /**
     * 获取昨天的开始时间 00:00:00:00
     *
     * @return
     */
    public static Date getYesterdayStartTime() {
        Date date = new Date();
        Calendar dateStart = Calendar.getInstance();
        dateStart.setTime(date);
        dateStart.add(Calendar.DATE, -1);
        dateStart.set(Calendar.HOUR_OF_DAY, 0);
        dateStart.set(Calendar.MINUTE, 0);
        dateStart.set(Calendar.SECOND, 0);
        dateStart.set(Calendar.MILLISECOND, 0);
        return dateStart.getTime();
    }

    /**
     * 获取明天的结束时间 23:59:59:999
     *
     * @return
     */
    public static Date getTomorrowEndTime() {
        Date date = new Date();
        Calendar dateEnd = Calendar.getInstance();
        dateEnd.setTime(date);
        dateEnd.add(Calendar.DATE, 1);
        dateEnd.set(Calendar.HOUR_OF_DAY, 23);
        dateEnd.set(Calendar.MINUTE, 59);
        dateEnd.set(Calendar.SECOND, 59);
        dateEnd.set(Calendar.MILLISECOND, 999);
        return dateEnd.getTime();
    }

    /**
     * 获取明天的开始时间 00:00:00:00
     *
     * @return
     */
    public static Date getTomorrowStartTime() {
        Date date = new Date();
        Calendar dateStart = Calendar.getInstance();
        dateStart.setTime(date);
        dateStart.add(Calendar.DATE, 1);
        dateStart.set(Calendar.HOUR_OF_DAY, 0);
        dateStart.set(Calendar.MINUTE, 0);
        dateStart.set(Calendar.SECOND, 0);
        dateStart.set(Calendar.MILLISECOND, 0);
        return dateStart.getTime();
    }

    /**
     * 获取每天的结束时间 23:59:59:999
     *
     * @param date
     * @return
     */
    public static Date getEndTime(Date date) {
        Calendar dateEnd = Calendar.getInstance();
        dateEnd.setTime(date);
        dateEnd.set(Calendar.HOUR_OF_DAY, 23);
        dateEnd.set(Calendar.MINUTE, 59);
        dateEnd.set(Calendar.SECOND, 59);
        dateEnd.set(Calendar.MILLISECOND, 999);
        return dateEnd.getTime();
    }


    /*
       参数举例  String dates="2018-11-11";
       星期日=星期7 此处根据需要灵活改动即可
    */
    public static String getWeek(String dates) {
        Calendar cal = Calendar.getInstance();
        SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd");
//		String[] weekDays = { "7", "1", "2", "3", "4", "5", "6" };
        String[] weekDays = {"sun", "mon", "tue", "wed", "thu", "fri", "sat"};
        Date d = null;
        try {
            d = f.parse(dates);
        } catch (ParseException e) {

            e.printStackTrace();
        }
        cal.setTime(d);
        int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
        return weekDays[w];
    }

    /*
       参数举例  String dates="2018-11-11";
       星期日=星期7 此处根据需要灵活改动即可
    */
    public static String getWeek(Date dates) {
        Calendar cal = Calendar.getInstance();
        String[] weekDays = {"sun", "mon", "tue", "wed", "thu", "fri", "sat"};
        cal.setTime(dates);
        int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
        return weekDays[w];
    }

    //获取yyyy-MM-dd是星期几
    public static int getWeekdayOfDateTime(String datetime) {
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        Calendar c = Calendar.getInstance();
        try {
            c.setTime(df.parse(datetime));
        } catch (Exception e) {
            e.printStackTrace();
        }
        int weekday = c.get(Calendar.DAY_OF_WEEK) - 1;
        return weekday;
    }

    public static int getWeekdayOfDateTime(Date date) {
//		DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        Calendar c = Calendar.getInstance();
        try {
            c.setTime(date);
        } catch (Exception e) {
            e.printStackTrace();
        }
        int weekday = c.get(Calendar.DAY_OF_WEEK) - 1;
        return weekday;
    }

    /**
     * @Author: umizhang
     * @Title: getStartOrEndDayOfQuarter
     * @Description TODO 获取本季度的第一天或最后一天
     * @Date: 2019/7/23 13:46
     * @Param: [today, isFirst: true 表示开始时间，false表示结束时间]
     * @return: java.lang.String
     * @Exception:
     */
    public static String getStartOrEndDayOfQuarter(LocalDate today, Boolean isFirst) {
        LocalDate resDate = LocalDate.now();
        if (today == null) {
            today = resDate;
        }
        Month month = today.getMonth();
        Month firstMonthOfQuarter = month.firstMonthOfQuarter();
        Month endMonthOfQuarter = Month.of(firstMonthOfQuarter.getValue() + 2);
        if (isFirst) {
            resDate = LocalDate.of(today.getYear(), firstMonthOfQuarter, 1);
        } else {
            resDate = LocalDate.of(today.getYear(), endMonthOfQuarter, endMonthOfQuarter.length(today.isLeapYear()));
        }
        if (isFirst) {
            resDate.atTime(0, 0, 0);
        } else {
            resDate.atTime(23, 59, 59);
        }
        return resDate.toString();
    }

    /**
     * @Author: umizhang
     * @Title: getStartOrEndOfYear
     * @Description TODO 获取本年的第一天或最后一天
     * @Date: 2019/7/23 13:48
     * @Param: [today, isFirst: true 表示开始时间，false表示结束时间]
     * @return: java.lang.String
     * @Exception:
     */
    public static String getStartOrEndDayOfYear(LocalDate today, Boolean isFirst) {
        LocalDate resDate = LocalDate.now();
        if (today == null) {
            today = resDate;
        }
        if (isFirst) {
            resDate = LocalDate.of(today.getYear(), Month.JANUARY, 1);
        } else {
            resDate = LocalDate.of(today.getYear(), Month.DECEMBER, Month.DECEMBER.length(today.isLeapYear()));
        }
        if (isFirst) {
            resDate.atTime(0, 0, 0);
        } else {
            resDate.atTime(23, 59, 59);
        }
        return resDate.toString();
    }

    /**
     * 组装查询日期
     *
     * @param queryCreateTimeTag   日期查询标签
     *                             "all 全部\n" +
     *                             "today 今天\n" +
     *                             "yesterday 昨天\n" +
     *                             "week 本周\n" +
     *                             "month 本月\n" +
     *                             "upMonth 上月\n" +
     *                             "quarter 本季度\n" +
     *                             "year 本年\n" +
     * @param queryStartCreateTime 自定义日期查询 开始时间 格式 yyyy-MM-dd HH:mm:ss
     * @param queryEndCreateTime   自定义日期查询 结束时间 格式 yyyy-MM-dd HH:mm:ss
     * @return
     */
    public static Map<String, Object> assembleQueryDate(String queryCreateTimeTag, Date queryStartCreateTime, Date queryEndCreateTime) {
        if ("all".equals(queryCreateTimeTag)) {
            queryStartCreateTime = null;
            queryEndCreateTime = null;
        } else if ("today".equals(queryCreateTimeTag)) {

            queryStartCreateTime = DateUtils.getStartTime(new Date());
            queryEndCreateTime = DateUtils.getEndTime(new Date());
        } else if ("yesterday".equals(queryCreateTimeTag)) {

            queryStartCreateTime = DateUtils.getYesterdayStartTime();
            queryEndCreateTime = DateUtils.getYesterdayEndTime();
        } else if ("week".equals(queryCreateTimeTag)) {
            queryStartCreateTime = DateUtils.getBeginWeekDate();
            queryEndCreateTime = DateUtils.getEndWeekDate();
        } else if ("month".equals(queryCreateTimeTag)) {
            queryStartCreateTime = DateUtils.getMonthStartDate();
            queryEndCreateTime = DateUtils.getMonthEndDate();
        } else if ("upMonth".equals(queryCreateTimeTag)) {
            queryStartCreateTime = DateUtils.getMonthStartDate(monthAddNum(new Date(), -1));
            queryEndCreateTime = DateUtils.getMonthEndDate(monthAddNum(new Date(), -1));
        } else if ("quarter".equals(queryCreateTimeTag)) {
            queryStartCreateTime = DateUtils.str2Date(DateUtils.getStartOrEndDayOfQuarter(LocalDate.now(), true), DateUtils.datetimeFormat);
            queryEndCreateTime = DateUtils.str2Date(DateUtils.getStartOrEndDayOfQuarter(LocalDate.now(), false), DateUtils.datetimeFormat);
        } else if ("year".equals(queryCreateTimeTag)) {
            queryStartCreateTime = DateUtils.str2Date(DateUtils.getStartOrEndDayOfYear(LocalDate.now(), true), DateUtils.datetimeFormat);
            queryEndCreateTime = DateUtils.str2Date(DateUtils.getStartOrEndDayOfYear(LocalDate.now(), false), DateUtils.datetimeFormat);
        }
        Map<String, Object> map = new HashMap<>();
        if (queryStartCreateTime == null) {
            queryStartCreateTime = DateUtils.str2Date("1900-01-01 00:00:00", DateUtils.datetimeFormat);
        }
        if (queryEndCreateTime == null) {
            queryEndCreateTime = new Date();
        }
        map.put("queryStartCreateTime", queryStartCreateTime);
        map.put("queryEndCreateTime", queryEndCreateTime);
        return map;
    }

    /**
     * 生成随机时间
     *
     * @param beginDate
     * @param endDate
     * @return
     */
    public static Date randomDate(String beginDate, String endDate) {
        try {
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            Date start = format.parse(beginDate);// 构造开始日期
            Date end = format.parse(endDate);// 构造结束日期
            // getTime()表示返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
            if (start.getTime() >= end.getTime()) {
                return null;
            }
            long date = random(start.getTime(), end.getTime());
            return new Date(date);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static long random(long begin, long end) {
        long rtn = begin + (long) (Math.random() * (end - begin));
        // 如果返回的是开始时间和结束时间，则递归调用本函数查找随机值
        if (rtn == begin || rtn == end) {
            return random(begin, end);
        }
        return rtn;
    }

    public static String addTime() {
        /** 开始时间     结束时间   */
        Date randomDate = DateUtils.randomDate("2020-01-01", DateUtils.date2Str(DateUtils.date_sdf));
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String result = format.format(randomDate);
        return result;
    }

    public static String getStringTime(Date date) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String result = format.format(date);
        return result;
    }

    public static String getStringTimeData(Date date) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String result = format.format(date);
        return result;
    }


    //获取两个日期相隔天数
    public static double getDays(Date before, Date after) {
        long beforeTime = before.getTime();
        long afterTime = after.getTime();
        return (afterTime - beforeTime) / (1000 * 60 * 60 * 24);
    }

    /**
     * 获取出生日期
     *
     * @return 返回日期格式
     */
    public static Date getBirthDayFromIdCard(String idCard) throws ParseException {
        Date birth = null;
        if (idCard.length() == 18) {
            String year = idCard.substring(6).substring(0, 4);// 得到年份
            String month = idCard.substring(10).substring(0, 2);// 得到月份
            String day = idCard.substring(12).substring(0, 2);// 得到日
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            birth = format.parse(year + "-" + month + "-" + day);
        } else if (idCard.length() == 15) {
            String year = "19" + idCard.substring(6, 8);// 年份
            String month = idCard.substring(8, 10);// 月份
            String day = idCard.substring(10, 12);// 得到日
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            birth = format.parse(year + "-" + month + "-" + day);
        }
        return birth;
    }


    public static Date transferString2Date(String s) {
        Date date = new Date();
        try {
            date = new SimpleDateFormat("yyyy-MM-dd").parse(s);
        } catch (ParseException e) {
            //LOGGER.error("时间转换错误, string = {}", s, e);
        }
        return date;
    }

}